package com.ts.service.achievement.impl;

import com.ts.dto.PatentDTO;
import com.ts.dto.PageDTO;
import com.ts.entity.Patent;
import com.ts.mapper.achievement.PatentMapper;
import com.ts.result.PageResult;
import com.ts.service.achievement.PatentService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/**
 * 专利服务实现类（简化逻辑）
 */
@Service
public class PatentServiceImpl implements PatentService {

    @Resource
    private PatentMapper patentMapper;

    /**
     * 新增专利（简化DTO转实体，保留核心校验）
     */
    @Override
    public void save(PatentDTO dto) {
        // 简单参数校验
        if (dto == null || ObjectUtils.isEmpty(dto.getPatentName())) {
            throw new IllegalArgumentException("专利名称不能为空");
        }

        // 直接构建实体（简化转换逻辑）
        Patent patent = new Patent();
        patent.setPatentName(dto.getPatentName());
        patent.setPatentType(dto.getPatentType());
        patent.setAuthor(dto.getAuthor());

        // 自动填充审计字段
        LocalDateTime now = LocalDateTime.now();
        patent.setCreateTime(now);
        patent.setUpdateTime(now);
        patent.setCreateBy(1L); // 模拟创建人
        patent.setUpdateBy(1L);

        patentMapper.insert(patent);
    }

    /**
     * 删除专利（简化返回值，只抛异常）
     */
    @Override
    public void deleteById(Long id) {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("ID不合法");
        }
        // 简单判断是否存在
        if (patentMapper.selectById(id) == null) {
            throw new RuntimeException("专利不存在");
        }
        patentMapper.deleteById(id);
    }

    /**
     * 更新专利（简化DTO处理）
     */
    @Override
    public void updateById(PatentDTO dto) {
        if (dto == null || dto.getId() == null || ObjectUtils.isEmpty(dto.getPatentName())) {
            throw new IllegalArgumentException("ID和专利名称不能为空");
        }

        Patent exist = patentMapper.selectById(dto.getId());
        if (exist == null) {
            throw new RuntimeException("专利不存在");
        }

        // 直接更新必要字段（保留创建信息）
        exist.setPatentName(dto.getPatentName());
        exist.setPatentType(dto.getPatentType());
        exist.setAuthor(dto.getAuthor());
        exist.setUpdateTime(LocalDateTime.now());
        exist.setUpdateBy(1L); // 模拟修改人

        patentMapper.updateById(exist);
    }
    /**
     * 查询单个专利（保持简单）
     */
    @Override
    public Patent getById(Long id) {
        return id == null || id <= 0 ? null : patentMapper.selectById(id);
    }
//
    /**
     * 分页查询（简化参数处理）
     */
    @Override
    public PageResult pageQuery(PageDTO dto) {
        // 简化分页参数默认值
        int pageNum = dto.getPageNum() == null || dto.getPageNum() < 1 ? 1 : dto.getPageNum();
        int pageSize = dto.getPageSize() == null || dto.getPageSize() < 1 ? 10 : dto.getPageSize();
        int offset = (pageNum - 1) * pageSize;

        // 直接查数据和总数，封装返回
        List<Patent> list = patentMapper.selectByPage(offset, pageSize);
        Long total = patentMapper.selectTotalCount();
        return new PageResult(total, list);
    }
}